تسلط بر استریم‌های ناهمزمان: ترکیب استریم با Async Iterator Helper در جاوا اسکریپت

            async function* asyncNumberGenerator(limit) {
  for (let i = 1; i <= limit; i++) {
    await new Promise(resolve => setTimeout(resolve, 100)); // Simulate async delay
    yield i;
  }
}

async function processAsyncStream() {
  const numbers = asyncNumberGenerator(5);
  for await (const num of numbers) {
    console.log(num);
  }
}

processAsyncStream();
// Output:
// 1
// 2
// 3
// 4
// 5

            

              
                Copy
              
            
          

            async function* asyncNumberGenerator(limit) {
  for (let i = 1; i <= limit; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

// Imagine a 'map' function that works with async iterators
async function* mapAsyncIterator(asyncIterator, transformFn) {
  for await (const value of asyncIterator) {
    yield await Promise.resolve(transformFn(value));
  }
}

async function processMappedStream() {
  const numbers = asyncNumberGenerator(5);
  const squaredNumbers = mapAsyncIterator(numbers, num => num * num);

  console.log("Squared numbers:");
  for await (const squaredNum of squaredNumbers) {
    console.log(squaredNum);
  }
}

processMappedStream();
// Output:
// Squared numbers:
// 1
// 4
// 9
// 16
// 25

            

              
                Copy
              
            
          

            async function* asyncNumberGenerator(limit) {
  for (let i = 1; i <= limit; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

// Imagine a 'filter' function for async iterators
async function* filterAsyncIterator(asyncIterator, predicateFn) {
  for await (const value of asyncIterator) {
    if (await Promise.resolve(predicateFn(value))) {
      yield value;
    }
  }
}

async function processFilteredStream() {
  const numbers = asyncNumberGenerator(10);
  const evenNumbers = filterAsyncIterator(numbers, num => num % 2 === 0);

  console.log("Even numbers:");
  for await (const evenNum of evenNumbers) {
    console.log(evenNum);
  }
}

processFilteredStream();
// Output:
// Even numbers:
// 2
// 4
// 6
// 8
// 10

            

              
                Copy
              
            
          

            async function* asyncNumberGenerator(limit) {
  for (let i = 1; i <= limit; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

// Imagine a 'reduce' function for async iterators
async function reduceAsyncIterator(asyncIterator, reducerFn, initialValue) {
  let accumulator = initialValue;
  for await (const value of asyncIterator) {
    accumulator = await Promise.resolve(reducerFn(accumulator, value));
  }
  return accumulator;
}

async function processReducedStream() {
  const numbers = asyncNumberGenerator(5);
  const sum = await reduceAsyncIterator(numbers, (acc, num) => acc + num, 0);

  console.log(`Sum of numbers: ${sum}`);
}

processReducedStream();
// Output:
// Sum of numbers: 15

            

              
                Copy
              
            
          

            async function* generatorA() {
  yield 'A1'; await new Promise(r => setTimeout(r, 50));
  yield 'A2';
}

async function* generatorB() {
  yield 'B1';
  yield 'B2'; await new Promise(r => setTimeout(r, 50));
}

// Imagine a 'concat' function
async function* concatAsyncIterators(...iterators) {
  for (const iterator of iterators) {
    for await (const value of iterator) {
      yield value;
    }
  }
}

async function processConcatenatedStream() {
  const streamA = generatorA();
  const streamB = generatorB();
  const concatenatedStream = concatAsyncIterators(streamA, streamB);

  console.log("Concatenated stream:");
  for await (const item of concatenatedStream) {
    console.log(item);
  }
}

processConcatenatedStream();
// Output:
// Concatenated stream:
// A1
// A2
// B1
// B2

            

              
                Copy
              
            
          

            async function* streamWithDelay(id, delay, count) {
  for (let i = 0; i < count; i++) {
    await new Promise(resolve => setTimeout(resolve, delay));
    yield `${id}:${i}`;
  }
}

// Imagine a 'merge' function (more complex to implement efficiently)
async function* mergeAsyncIterators(...iterators) {
  const iteratorsState = iterators.map(it => ({ iterator: it[Symbol.asyncIterator](), nextPromise: null }));
  
  // Initialize first next promises
  iteratorsState.forEach(state => {
    state.nextPromise = state.iterator.next().then(result => ({ ...result, index: iteratorsState.indexOf(state) }));
  });

  let pending = iteratorsState.length;
  while (pending > 0) {
    const winner = await Promise.race(iteratorsState.map(state => state.nextPromise));

    if (!winner.done) {
      yield winner.value;
      // Fetch next from the winning iterator
      iteratorsState[winner.index].nextPromise = iteratorsState[winner.index].iterator.next().then(result => ({ ...result, index: winner.index }));
    } else {
      // Iterator is done, remove it from pending
      pending--;
      iteratorsState[winner.index].nextPromise = Promise.resolve({ done: true, index: winner.index }); // Mark as done
    }
  }
}

async function processMergedStream() {
  const stream1 = streamWithDelay('S1', 200, 3);
  const stream2 = streamWithDelay('S2', 150, 4);

  const mergedStream = mergeAsyncIterators(stream1, stream2);

  console.log("Merged stream:");
  for await (const item of mergedStream) {
    console.log(item);
  }
}

processMergedStream();
/* Sample Output (order can vary slightly due to timing):
Merged stream:
S2:0
S1:0
S2:1
S1:1
S2:2
S1:2
S2:3
*/

            

              
                Copy
              
            
          

            async function* asyncNumberGenerator(limit) {
  for (let i = 1; i <= limit; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

// Imagine a 'batch' function
async function* batchAsyncIterator(asyncIterator, batchSize) {
  let batch = [];
  for await (const value of asyncIterator) {
    batch.push(value);
    if (batch.length === batchSize) {
      yield batch;
      batch = [];
    }
  }
  if (batch.length > 0) { // Yield any remaining items
    yield batch;
  }
}

async function processBatchedStream() {
  const numbers = asyncNumberGenerator(7);
  const batchedNumbers = batchAsyncIterator(numbers, 3);

  console.log("Batched numbers:");
  for await (const batch of batchedNumbers) {
    console.log(batch);
  }
}

processBatchedStream();
// Output:
// Batched numbers:
// [ 1, 2, 3 ]
// [ 4, 5, 6 ]
// [ 7 ]

            

              
                Copy
              
            
          

            // Placeholder for a debouncing function for async iterators
// This would typically involve timers and state management.
// For simplicity, we'll describe the behavior.

async function* debounceAsyncIterator(asyncIterator, delayMs) {
  let lastValue;
  let timeoutId;
  let isWaiting = false;

  for await (const value of asyncIterator) {
    lastValue = value;
    if (timeoutId) {
      clearTimeout(timeoutId);
    }
    if (!isWaiting) {
      isWaiting = true;
      timeoutId = setTimeout(async () => {
        yield lastValue;
        isWaiting = false;
      }, delayMs);
    }
  }

  // If there's a pending value after the loop finishes
  if (isWaiting && lastValue !== undefined) {
    yield lastValue;
  }
}

// Simulate a stream of search queries
async function* simulateSearchQueries() {
  yield 'jav';
  await new Promise(r => setTimeout(r, 100));
  yield 'java';
  await new Promise(r => setTimeout(r, 100));
  yield 'javas';
  await new Promise(r => setTimeout(r, 500)); // Pause
  yield 'javasc';
  await new Promise(r => setTimeout(r, 300)); // Pause
  yield 'javascript';
}

async function processDebouncedStream() {
  const queries = simulateSearchQueries();
  const debouncedQueries = debounceAsyncIterator(queries, 400); // Wait 400ms after last input

  console.log("Debounced search queries:");
  for await (const query of debouncedQueries) {
    console.log(`Triggering search for: "${query}"`);
    // In a real app, this would call an API.
  }
}

processDebouncedStream();
/* Sample Output:
Debounced search queries:
Triggering search for: "javascript"
*/

            

              
                Copy
              
            
          

            // Assume these are async iterators returning user objects { id: number, name: string, isActive: boolean }

async function* fetchPaginatedUsers(page) {
  console.log(`Fetching page ${page}...`);
  await new Promise(resolve => setTimeout(resolve, 300));
  // Simulate data for different pages
  if (page === 1) {
    yield { id: 1, name: 'Alice', isActive: true };
    yield { id: 2, name: 'Bob', isActive: false };
    yield { id: 3, name: 'Charlie', isActive: true };
  } else if (page === 2) {
    yield { id: 4, name: 'David', isActive: true };
    yield { id: 5, name: 'Eve', isActive: false };
    yield { id: 6, name: 'Frank', isActive: true };
  }
}

// Function to get the next page of users
async function getNextPageOfUsers(currentPage) {
  // In a real scenario, this would check if there's more data
  if (currentPage < 2) {
    return fetchPaginatedUsers(currentPage + 1);
  }
  return null; // No more pages
}

// Simulate a 'flatMap' or 'concatMap' like behavior for paginated fetching
async function* flatMapAsyncIterator(asyncIterator, mapFn) {
  for await (const value of asyncIterator) {
    const mappedIterator = mapFn(value);
    for await (const innerValue of mappedIterator) {
      yield innerValue;
    }
  }
}

async function complexStreamPipeline() {
  // Start with the first page
  let currentPage = 0;
  const initialUserStream = fetchPaginatedUsers(currentPage + 1);

  // Chain operations:
  const processedStream = initialUserStream
    .pipe(
      // Add pagination: if a user is the last on a page, fetch the next page
      flatMapAsyncIterator(async (user, stream) => {
        const results = [user];
        // This part is a simplification. Real pagination logic might need more context.
        // Let's assume our fetchPaginatedUsers yields 3 items and we want to fetch next if available.
        // A more robust approach would be to have a source that knows how to paginate itself.
        return results;
      }),
      filterAsyncIterator(user => user.isActive),
      mapAsyncIterator(user => ({ ...user, name: user.name.toUpperCase() })),
      batchAsyncIterator(2) // Batch into groups of 2
    );

  console.log("Complex pipeline results:");
  for await (const batch of processedStream) {
    console.log(batch);
  }
}

// This example is conceptual. Actual implementation of flatMap/pagination chaining
// would require more advanced state management within the stream helpers.
// Let's refine the approach for a clearer example.

// A more realistic approach to handling pagination using a custom source
async function* paginatedUserSource(totalPages) {
  for (let page = 1; page <= totalPages; page++) {
    yield* fetchPaginatedUsers(page);
  }
}

async function sophisticatedStreamComposition() {
  const userSource = paginatedUserSource(2); // Fetch from 2 pages

  const pipeline = userSource
    .pipe(
      filterAsyncIterator(user => user.isActive),
      mapAsyncIterator(user => ({ ...user, name: user.name.toUpperCase() })),
      batchAsyncIterator(2)
    );

  console.log("Sophisticated pipeline results:");
  for await (const batch of pipeline) {
    console.log(batch);
  }
}

sophisticatedStreamComposition();
/* Sample Output:
Sophisticated pipeline results:
[ { id: 1, name: 'ALICE', isActive: true }, { id: 3, name: 'CHARLIE', isActive: true } ]
[ { id: 4, name: 'DAVID', isActive: true }, { id: 6, name: 'FRANK', isActive: true } ]
*/

            

              
                Copy